/** @type {Object} 网络请求 */
import axios from 'axios'
import Util from './test.js'
import Message from './message.js'
import Store from '@/store'
import Settings from '@/settings/projectSetting.js'
import signature from './signature.js'
import Router from '@/router'
const codeMessage = {
  200: '服务器成功返回请求的数据',
  201: '新建或修改数据成功',
  202: '一个请求已经进入后台排队（异步任务）',
  204: '删除数据成功',
  400: '发出的请求有错误，服务器没有进行新建或修改数据的操作',
  401: '用户没有权限（令牌、用户名、密码错误）',
  403: '用户得到授权，但是访问是被禁止的',
  404: '发出的请求是不存在的记录，服务器没有进行操作',
  406: '请求的格式不可得',
  410: '请求的资源被永久删除，且不会再得到的',
  422: '当创建一个对象时，发生一个验证错误',
  500: '服务器发生错误，请检查服务器',
  502: '网关错误',
  503: '服务不可用，服务器暂时过载或维护',
  504: '网关超时'
}
const http = {
  /**
   * 获取请求实例
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   */
  instance: _config => {
    _config = Util.isJson(_config) ? _config : {}
    let _init = {
      baseURL: Settings.globApiUrl
    }
    let token = Store.getters['user/token'] || { ak: '', sk: '' }
    Util.extend(_init, _config)
    axios.defaults.headers.common['Is-Axios'] = 1
    axios.defaults.headers.common['E-DEVICE-TYPE'] = Settings.globDeviceType
    axios.defaults.headers.common['E-APP-ID'] = Settings.globAppId
    axios.defaults.headers.common['E-USER-AK'] = token.ak
    axios.defaults.headers.common['E-USER-SK'] = token.sk
    axios.defaults.headers.common['E-MHM-ID'] = Store.state.projectSetting.e_app_mhm_id
    axios.defaults.headers.common['E-SHARE-CODE'] = Store.state.projectSetting.globShareCode

    let instance = axios.create(_init)
    // 设置请求拦截器
    instance.interceptors.request.use(config => {
      let params = config.data || config.params
      if (!Util.object(params)) {
        params = {}
      }
      config.headers = {
        ...config.headers,
        ...signature(params)
      }
      return config
    })
    instance.interceptors.response.use(
      response => {
        return Promise.resolve(response)
      },
      error => {
        if (error === undefined || error.code === 'ECONNABORTED') {
          Message.error('服务请求超时')
          return Promise.reject(error)
        }
        const {
          response: {
            status,
            statusText,
            data: { msg = '', data = {} }
          }
        } = error
        // 如果是401错误
        if (status === 401) {
          Store.dispatch('loading/setLoading')
          if (Util.isEmpty(Router.currentRoute.query.redirect)) {
            Router.replace({
              path: Store.getters['projectSetting/getGlobLoginConfigLink'],
              query: {
                redirect: Router.currentRoute.fullPath
              }
            })
          }
        }
        // 如果返回402错误，登录失效,清除登录token
        if (data.error_code == 402) {
          Store.dispatch('user/compelLogout')
          if (Util.isEmpty(Router.currentRoute.query.redirect)) {
            Router.replace({
              path: Store.getters['projectSetting/getGlobLoginConfigLink'],
              query: {
                redirect: Router.currentRoute.fullPath
              }
            })
          }
        }
        let msgText = msg || codeMessage[status] || statusText
        console.log(`${status}:${msgText}`)
        return Promise.reject(error)
      }
    )
    return instance
  },
  /**
   * 携带body参数
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  data    请求body数据
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolen} loading 指定为false时,不显示loading,默认0.6s后显示
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  sendWidthData: function(uri, data, callbackSuccess, callbackError, loading, config) {
    var loadingVist = false
    if (!Util.isFalse(loading)) {
      Store.dispatch('loading/setLoading', true, {
        root: true
      })
      loadingVist = true
    }
    return this.instance(config)
      .post(uri, data)
      .then(function(response) {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        if (response.data.code == 1) {
          // 后台处理成功,是否定义了成功的处理方法
          if (Util.isFunction(callbackSuccess)) {
            return callbackSuccess(response.data)
          }
        } else {
          // 后台处理失败,是否定义了失败的处理方法
          if (Util.isFunction(callbackError)) {
            return callbackError(response.data)
          }
        }
        // 默认处理
        return response.data
      })
      .catch(function(error) {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        return false
      })
  },
  /**
   * url参数
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  params  请求携带的params数据,会拼接到url
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolen} loading 指定为false时,不显示loading,默认0.6s后显示
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  sendWidthParams: function(uri, params, callbackSuccess, callbackError, loading, config) {
    var loadingVist = false
    if (!Util.isFalse(loading)) {
      Store.dispatch('loading/setLoading', true, {
        root: true
      })

      loadingVist = true
    }
    return this.instance(config)
      .get(uri, {
        params: params
      })
      .then(response => {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        if (Util.isJson(response.data)) {
          if (response.data.code == 1) {
            // 后台处理成功,是否定义了成功的处理方法
            if (Util.isFunction(callbackSuccess)) {
              return callbackSuccess(response.data)
            }
          } else {
            // 后台处理失败,是否定义了失败的处理方法
            if (Util.isFunction(callbackError)) {
              return callbackError(response.data)
            }
          }
          // 默认处理
          return response.data
        } else {
          if (Util.isFunction(callbackSuccess)) {
            return callbackSuccess(response.data)
          }
        }
      })
      .catch(err => {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        return false
      })
  },
  /**
   * get请求
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  params  请求携带的params数据,会拼接到url
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolean} loading 是否显示loading层,为false时不显示
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  get: function(uri, params, callbackSuccess, callbackError, loading, config) {
    return this.sendWidthParams(uri, params, callbackSuccess, callbackError, loading, config)
  },
  /**
   * post请求
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  data    请求body数据
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolean} loading 是否显示loading层,为false时不显示
   * @param    {object|json} config 请求配置
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  post: function(uri, data, callbackSuccess, callbackError, loading, config) {
    return this.sendWidthData(uri, data, callbackSuccess, callbackError, loading, config)
  },
  /**
   * delete请求
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  data    请求body数据
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolean} loading 是否显示loading层,为false时不显示
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  delete: function(uri, data, callbackSuccess, callbackError, loading) {
    var loadingVist = false
    if (!Util.isFalse(loading)) {
      Store.dispatch('loading/setLoading', true, {
        root: true
      })

      loadingVist = true
    }
    return this.instance()
      .delete(uri, { data })
      .then(response => {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        if (response.data.code == 1) {
          // 后台处理成功,是否定义了成功的处理方法
          if (Util.isFunction(callbackSuccess)) {
            return callbackSuccess(response.data)
          } else {
            response = response.data
            Message.success(response.msg)
          }
        } else {
          // 后台处理失败,是否定义了失败的处理方法
          if (Util.isFunction(callbackError)) {
            return callbackError(response.data)
          } else {
            response = response.data
            Message.error(response.msg)
          }
        }
        // 默认处理
        return response.data
      })
      .catch(err => {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        return false
      })
  },
  /**
   * put请求
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-15
   * @param    {string}   uri 请求地址,不包含根域名
   * @param    {any}  data    请求body数据
   * @param    {function} callbackSuccess 成功回调处理方法
   * @param    {function} callbackError   失败回调处理方法
   * @param    {boolean} loading 是否显示loading层,为false时不显示
   * @return   处理结果 | 未指定回调方法时,返回后端响应的数据
   */
  put: function(uri, data, callbackSuccess, callbackError, loading) {
    var loadingVist = false
    if (!Util.isFalse(loading)) {
      Store.dispatch('loading/setLoading', true, {
        root: true
      })

      loadingVist = true
    }
    return this.instance()
      .put(uri, data)
      .then(function(response) {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        if (response.data.code == 1) {
          // 后台处理成功,是否定义了成功的处理方法
          if (Util.isFunction(callbackSuccess)) {
            return callbackSuccess(response.data)
          }
        } else {
          // 后台处理失败,是否定义了失败的处理方法
          if (Util.isFunction(callbackError)) {
            return callbackError(response.data)
          }
        }
        // 默认处理
        return response.data
      })
      .catch(function(err) {
        loadingVist &&
          Store.dispatch('loading/setLoading', false, {
            root: true
          })
        return false
      })
  },
  /**
   * 通用入口
   * @Author   Martinsun<syh@sunyonghong.com>
   * @DateTime 2020-02-16
   * @param    {string}                       method          请方式
   * 其他参数见各个请求方法
   */
  send: function(method, uri, data, callbackSuccess, callbackError, loading) {
    method = method.toLowerCase()
    return eval('this.' + method + '(uri,data,callbackSuccess,callbackError,loading)')
  }
}

export default http
